/**
 * Description:
 * Date: 2025-10-01
 * Time: 22:23
 */
public class Test {
    public static void main1(String[] args) {
        //方法的语法定义
        // 修饰符 返回值类型 方法名 （形参参数列表）

        //方法在栈中： 当执行一个方法时，会在栈中开辟一个内存，方法内的各种变量在这个内存中
    }

    public static void func(int year){//func方法在栈中额外开辟一个内存，不与main方法相连，方法执行完后会被java回收内存（销毁）
        //java当中 拿不到栈上局部变量的地址
        year = 100;
    }

    public static void main2(String[] args) {
        int year = 2025;
        func(year);
        System.out.println(year);//2025  形参的数据变化不会影响到实参数据
    }

    public static boolean isLeapYear (int year){
        System.out.println("方法被调用了！！！");
        if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0 ){
            return true;//你返回的数据类型要与方法的返回值类型一致
        }else {
            return false;
        }
    }

    public static void main3(String[] args) {
        int year = 2008;
        boolean ret = isLeapYear(year);//接受的局部变量类型需与方法的返回值类型一致
        if(ret == true)
        System.out.println(year + "是闰年");
    }

    public static void add(int a,int b){
        System.out.println(a + b);
    }

    public static void add(double b,double a){
        System.out.println(a + b);
    }

    public static void add(int b,int a,short c){
        System.out.println(a + b + c);
    }

    public static int add(int b,short a,int c){//顺序看的是数据类型的顺序，需要数据类型的顺序不一样才行

        return a + b + c;//与返回值类型无关
    }


    //方法重载
    public static void main4(String[] args) {
        //方法重载定义：1.方法名一样 3.形参的参数类型不一样（类型 数量 顺序） 3.与返回值类型无关
        int a = 10;
        int b = 20;
        add(a,b);
        add(10.2,20.4);//小数默认是double类型，所以不需要下面的强转
        add(11,22, (short) 33);//整数默认是int类型，其它整型需要强转
        int ret = add(111,(short) 222,333);
        System.out.println(ret);
    }

    public static int fac(int n){
        if(n == 1){//必须要有结束条件，否则会一直递归下去，而每次递归创建的方法会在栈中占一定的内存，直到栈满报错
            return 1;
        }
        return n * fac(n-1);
    }

    public static void main5(String[] args) {
        int n = 5;
        int ret = fac(5);
        System.out.println(ret);
    }

    //递归求出整数n每位上对应的值
    public static void print(int n){
        if(n < 10){
            System.out.print(n + " ");
            return;
        }
        print(n/10);//n/10就是递推公式
        System.out.print(n % 10 + " ");//这个就是你所要求的结果，是放在递归方法中合适的位置
    }

    public static void main6(String[] args) {
        int n = 123;
        print(n);
    }

    public static int sum(int n){
        if(n == 1){
            return 1;
        }
        return n + sum(n - 1);
    }

    //递归求1-10的和
    public static void main7(String[] args) {
        int n = 10;
        int ret = sum(n);
        System.out.println(ret);
    }

    public static int fun2(int n){
        if(n < 10){
            return n;//这是递归结束条件
        }
        return n % 10 + fun2(n / 10);
    }

    //递归求一个非负整数，组成它的数字之和。如：1729 ——> 1+ 7 + 2 + 9 = 19
    public static void main8(String[] args) {
        int n = 1729;
        int ret = fun2(n);
        System.out.println(ret);

    }

    //递归求斐波那契数列 1 1 2 3 5 8 ...... 开始的两个数始固定是1 (每一项等于前两项之和)
    //求一个数的斐波那契不建议使用递归来求
    public static int fib(int n){
        if(n == 1 || n == 2){
            return 1;//求 2 的斐波那契数列就是1
        }
        return fib(n - 1) + fib(n - 2);
    }

    public static int fbnq(int n){
        int f1 = 1;//第一个斐波那契值
        int f2 = 1;//第二个
        int f3 = 0;
        //那么就要从第三个斐波那契值开始
        for (int i = 3; i <= n; i++) {
            f3 = f1 + f2;
            f1 = f2;
            f2 = f3;
        }
        return f3;

    }
    public static void main(String[] args) {
        int n = 40;
        int ret = fib(n);
        System.out.println(ret);
        System.out.println(fbnq(40));
    }


}


